package com.xuecheng.content.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xuecheng.api.content.model.dto.CourseBaseDTO;
import com.xuecheng.api.content.model.dto.CourseTeacherDTO;
import com.xuecheng.api.content.model.qo.QueryCourseModel;
import com.xuecheng.api.content.model.vo.CourseBaseVO;
import com.xuecheng.common.domain.page.PageRequestParams;
import com.xuecheng.common.domain.page.PageVO;
import com.xuecheng.common.enums.common.AuditEnum;
import com.xuecheng.common.enums.common.CommonEnum;
import com.xuecheng.common.enums.content.CourseAuditEnum;
import com.xuecheng.common.enums.content.CourseChargeEnum;
import com.xuecheng.common.enums.content.CourseModeEnum;
import com.xuecheng.common.exception.ExceptionCast;
import com.xuecheng.common.util.StringUtil;
import com.xuecheng.content.common.constant.ContentErrorCode;
import com.xuecheng.content.convert.CourseBaseConvert;
import com.xuecheng.content.entity.CourseBase;
import com.xuecheng.content.entity.CourseMarket;
import com.xuecheng.content.mapper.CourseBaseMapper;
import com.xuecheng.content.service.CourseBaseService;
import com.xuecheng.content.service.CourseMarketService;
import com.xuecheng.content.service.CourseTeacherService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Collections;
import java.util.List;

/**
 * <p>
 * 课程基本信息 服务实现类
 * </p>
 *
 * @author itcast
 */
@Slf4j
@Service
public class CourseBaseServiceImpl extends ServiceImpl<CourseBaseMapper, CourseBase> implements CourseBaseService {


    @Autowired
    private CourseMarketService courseMarketService;

    @Autowired
    private CourseTeacherService courseTeacherService;

    /* 分析
       1.是否开始事务 --本次仅查询不开启事务
       2.条件判断  --
            分页条件 --需判断是否为非法数据 即 是否为0与负数
            查询条件 --是否是全部查询还是按条件查询
       3.返回数据 -- 将 PO-->DTO 并返回数据
                 --返回数据中包含 分页数据，总条数与查询数据库所得信息
     */
    public PageVO<CourseBaseDTO> queryCourseBase(PageRequestParams params, QueryCourseModel model, Long companyId) {

        //判断是否为非法数据
        Long pageNo = params.getPageNo();//当前页
        Integer pageSize = params.getPageSize();//每页显示条数
        if (pageNo < 1) {
            params.setPageNo(PageRequestParams.DEFAULT_PAGE_NUM);
        }
        if (pageSize < 1) {
            params.setPageSize(PageRequestParams.DEFAULT_PAGE_SIZE);
        }

        //查询条件
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        //机构ID不为空时 说明是机构查询的将ID拼接进条件，
        // 为空说明运营查询查询全部，不是查询某个机构的
        if (!ObjectUtils.isEmpty(companyId)){
            queryWrapper.eq(CourseBase::getCompanyId, companyId);
        }

        //判断条件 是否为空
        String courseName = model.getCourseName();
        if (StringUtil.isNotBlank(courseName)) {
            queryWrapper.like(CourseBase::getCompanyName, courseName);
        }
        String auditStatus = model.getAuditStatus();
        if (StringUtil.isNotBlank(auditStatus)) {
            queryWrapper.like(CourseBase::getAuditStatus, courseName);
        }

        //创建分页
        Page<CourseBase> courseBasePage = new Page<>(pageNo, pageSize);

        Page<CourseBase> basePage = this.page(courseBasePage, queryWrapper);

        //总条数
        long total = basePage.getTotal();
        //查询的数据
        List<CourseBase> records = basePage.getRecords();

        List<CourseBaseDTO> dtos = Collections.EMPTY_LIST;
        //判断查询到的数据是否为空
        if (!(CollectionUtils.isEmpty(records))) {
            dtos = CourseBaseConvert.INSTANCE.entity2dtos(records);
        }

        return new PageVO<CourseBaseDTO>(dtos, total, pageNo, pageSize);
    }

    /*
       业务分析
         事务:添加操作--开启事务
         参数： CourseBaseVO  companyId
            判断关键信息是否存在：
                -- mt 课程分类
                -- grade 课程等级
                -- users 适用人群
                -- pic 课程封面
                -- charge 收费规则 -- 若收费 则价格不可缺失
            需将 VO --> DTO
            Float类型有精度丢失问题，DTO中使用的 BigDecimal 类型
            价格因类型不一致需要单独转
         数据库操作：
            在将DTO-->PO
            添加到课程基本信息数据表(course_base)中，并将收费规则，价格添加到课程营销表(course_market)中
         返回数据 ： 将DTO返回，返回时将 收费规则 价格 添加进去在返回数据
     */
    @Transactional
    public CourseBaseDTO getCourse(CourseBaseVO baseVO, Long companyId) {
        //参数： CourseBaseVO  companyId
        //            判断关键信息是否存在：
        //                -- mt 课程分类
        //                -- grade 课程等级
        //                -- users 适用人群
        //                -- pic 课程封面
        //                -- charge 收费规则 -- 若收费 则价格不可缺失

        estimateCourseBaseVo(baseVO);

        //            需将 VO --> DTO
        //            Float类型有精度丢失问题，DTO中使用的 BigDecimal 类型
        //            价格因类型不一致需要单独转
        CourseBaseDTO dto = CourseBaseConvert.INSTANCE.vo2dto(baseVO);

        if (!ObjectUtils.isEmpty(baseVO.getPrice())) { //价格不为空 在写入
            dto.setPrice(new BigDecimal(baseVO.getPrice().toString()));
        }

        //对新增的课程添加审核的默认状态：未提交
        dto.setAuditStatus(AuditEnum.AUDIT_UNPAST_STATUS.getCode());
        if (ObjectUtils.isEmpty(companyId)) {
            throw new RuntimeException("机构ID不能为空");
        }
        dto.setCompanyId(companyId);

        //         数据库操作：
        //            在将DTO-->PO
        CourseBase courseBase = CourseBaseConvert.INSTANCE.dto2entity(dto);

        //添加到课程基本信息数据表(course_base)中，
        boolean saveCourse = this.save(courseBase);
        if (!saveCourse) {
            throw new RuntimeException("课程信息添加失败");
        }

        CourseBaseDTO baseDTO = CourseBaseConvert.INSTANCE.entity2dto(courseBase);

        //判断当课程免费是不加入课程营销表中
        CourseMarket courseMarket = new CourseMarket();
        if (!CourseChargeEnum.CHARGE_NO.getCode().equals(baseVO.getCharge())) {
            //并将收费规则，价格添加到课程营销表(course_market)中
            courseMarket.setCourseId(courseBase.getId());
            courseMarket.setCharge(dto.getCharge());
            courseMarket.setPrice(dto.getPrice().floatValue());
            boolean marketResult = courseMarketService.save(courseMarket);
            if (!marketResult) {
                throw new RuntimeException("保存课程营销数据失败");
            }
        }

        // 返回数据 ： 将DTO返回，返回时将 收费规则 价格 添加进去在返回数据
        CourseBaseDTO resultDto = CourseBaseConvert.INSTANCE.entity2dto(courseBase);
        String charge = courseMarket.getCharge();
        if (ObjectUtils.isEmpty(charge)) {
            //为null时 说明免费
            resultDto.setCharge(CourseChargeEnum.CHARGE_NO.getCode());
            resultDto.setPrice(new BigDecimal(0));
        } else {
            //不为空说明收费
            resultDto.setCharge(CourseChargeEnum.CHARGE_YES.getCode());
            resultDto.setPrice(new BigDecimal(courseMarket.getPrice().toString()));
        }


        return resultDto;
    }

    /*
    业务分析
         查询不需要开启事务
         关键条件判断-courseBaseId companyId 不能为空
         根据 课程ID 与 机构ID 查询课程基本信息
         并根据课程ID 查询课程收费规则和价格
         并将查询的PO类-->DTO类
         将DTO返回
     */
    public CourseBaseDTO getCourseBaser(Long courseBaseId, Long companyId) {
        if (ObjectUtils.isEmpty(courseBaseId)) {
            throw new RuntimeException("课程ID不能为空");
        }
        if (ObjectUtils.isEmpty(companyId)) {
            throw new RuntimeException("机构ID不能为空");
        }

        //根据 课程ID 与 机构ID 查询课程基本信息
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseBase::getCompanyId, companyId);
        queryWrapper.eq(CourseBase::getId, courseBaseId);
        CourseBase courseBase = this.getOne(queryWrapper);

        //判断课程信息是否存在
        if (ObjectUtils.isEmpty(courseBase)) {
            throw new RuntimeException("课程信息查询失败");
        }
        CourseBaseDTO courseBaseDTO = CourseBaseConvert.INSTANCE.entity2dto(courseBase);

        //并根据课程ID 查询课程收费规则和价格
        CourseMarket courseMarket = courseMarketService.queryCourseMarket(courseBaseId);
        if (!ObjectUtils.isEmpty(courseMarket)) {
            courseBaseDTO.setCharge(courseMarket.getCharge());
            courseBaseDTO.setPrice(new BigDecimal(courseMarket.getPrice().toString()));
        }


        return courseBaseDTO;
    }

    /*
       业务分析
          修改--需要开启业务
          关键数据
          baseVO --前端传入参数 部分字段不为空
          companyId --机构ID 不为空
          将VO-->DTO-->PO
          根据PO类 修改数据库信息
          修改问基本信息后，根据收费规则，取修改课程营销表
          最后返回DTO
     */
    @Transactional
    public CourseBaseDTO modifyCourseBaser(CourseBaseVO baseVO, Long companyId) {
        //baseVO --前端传入参数 部分字段不为空
        estimateCourseBaseVo(baseVO);
        CourseBaseDTO courseBaseDTO = CourseBaseConvert.INSTANCE.vo2dto(baseVO);

        courseBaseDTO.setAuditStatus(CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode());

        //companyId --机构ID 不为空
        if (ObjectUtils.isEmpty(companyId)) {
            throw new RuntimeException("机构ID不能为空");
        }

        CourseBase courseBase = CourseBaseConvert.INSTANCE.dto2entity(courseBaseDTO);
        //刚添加课程 审核状态为未审核
        courseBase.setAuditStatus(AuditEnum.AUDIT_UNPAST_STATUS.getCode());

        // 根据PO类,课程ID，机构ID 修改数据库信息
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<CourseBase>();
        queryWrapper.eq(CourseBase::getCompanyId, companyId);
        queryWrapper.eq(CourseBase::getId, baseVO.getCourseBaseId());
        boolean updateCourse = this.update(courseBase, queryWrapper);
        if (!updateCourse) {
            throw new RuntimeException("修改数据失败");
        }

        CourseBaseDTO baseDTO = CourseBaseConvert.INSTANCE.entity2dto(courseBase);

        //根据课程ID查询课程营销信息，存在 修改，不存在添加
        CourseMarket courseMarket = courseMarketService.queryCourseMarket(courseBaseDTO.getCourseBaseId());

        if (ObjectUtils.isEmpty(courseMarket)) { //判断该课程是否存在 营销信息 --不存在 添加
            //判断是否收费 如收费在进行修改添加
            if (CourseChargeEnum.CHARGE_YES.getCode().equals(baseVO.getCharge())) { //收费 添加
                baseDTO.setCharge(baseVO.getCharge());
                baseDTO.setPrice(new BigDecimal(baseVO.getPrice().toString()));
                courseMarketService.createCourseMarket(baseDTO); //添加课程信息
            }

        } else {//存在 修改
            if (CourseChargeEnum.CHARGE_YES.getCode().equals(baseVO.getCharge())) { //收费 修改
                baseDTO.setCharge(baseVO.getCharge());
                baseDTO.setPrice(new BigDecimal(baseVO.getPrice().toString()));
                courseMarketService.modifyCourseMarket(baseDTO); //修改课程信息
            }
        }


        return baseDTO;
    }

    private void estimateCourseBaseVo(CourseBaseVO baseVO) {
        if (StringUtil.isBlank(baseVO.getMt())) {
//            throw new RuntimeException("课程分类添加失败");
            ExceptionCast.cast(ContentErrorCode.E_120002);
        }
        if (StringUtil.isBlank(baseVO.getGrade())) {
//            throw new RuntimeException("课程等级添加失败");
            ExceptionCast.cast(ContentErrorCode.E_120007);
        }
//        if (StringUtil.isBlank(baseVO.getUsers())){
//            throw new RuntimeException("适用人群添加失败");
//        }
        ExceptionCast.cast(StringUtil.isBlank(baseVO.getUsers()), ContentErrorCode.E_120018);
        if (StringUtil.isBlank(baseVO.getPic())) {
//            throw new RuntimeException("课程封面添加失败");
            ExceptionCast.cast(ContentErrorCode.E_120019);
        }
        if (CourseChargeEnum.CHARGE_YES.getCode().equals(baseVO.getCharge())) {
            if (ObjectUtils.isEmpty(baseVO.getPrice())) {
//                throw new RuntimeException("收费课程，价格不能为空");
                ExceptionCast.cast(ContentErrorCode.E_120110);
            }
        }


    }


    /* 根据课程ID逻辑删除课程基本信息
        业务分析
           关键数据：courseBaseId  companyId 不为空
           业务数据：查询 课程基本信息 不为空在修改
        返回数据 Boolean
     */
    @Transactional
    public Boolean removeCourseBase(Long courseBaseId, Long companyId) {

        if (ObjectUtils.isEmpty(companyId)) {
            throw new RuntimeException("机构ID不能为空");
        }
        if (ObjectUtils.isEmpty(courseBaseId)) {
            throw new RuntimeException("课程ID不能为空");
        }
        //先查询课程基本信息
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseBase::getId, courseBaseId);
        queryWrapper.eq(CourseBase::getCompanyId, companyId);
        CourseBase courseBase = this.getOne(queryWrapper);
        if (ObjectUtils.isEmpty(courseBase)) {
            throw new RuntimeException("查询不到要修改课程基本信息");
        }

        //逻辑删除 status 属性 改为删除 0
        courseBase.setStatus(CommonEnum.DELETE_FLAG.getCodeInt());
        //修改
        boolean update = this.updateById(courseBase);
        if (!update) {
            throw new RuntimeException("逻辑删除课程基本信息失败");
        }

        return update;
    }

    /*业务分析
        关键数据 courseBaseId  companyId 不为空
        业务数据
              课程基本信息 不为空
              课程是否删除
              课程审核状态 不能是已提交与审核中  才能提交进行审核
        修改数据
               audtiStatus 审核状态--已提交

        判断修改是否成功
     */
    @Transactional
    public void modifyCourseBaseById(Long courseBaseId, Long companyId) {

        //关键数据 courseBaseId  companyId 不为空
        if (ObjectUtils.isEmpty(courseBaseId) ||
                ObjectUtils.isEmpty(companyId)
        ) {
            ExceptionCast.cast(ContentErrorCode.E_120023);
        }

        //课程基本信息 不为空
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseBase::getId, courseBaseId);
        queryWrapper.eq(CourseBase::getCompanyId, companyId);
        CourseBase courseBase = this.getOne(queryWrapper);
        ExceptionCast.cast(ObjectUtils.isEmpty(courseBase), ContentErrorCode.E_120013);

        //课程是否删除
        Integer status = courseBase.getStatus();
        ExceptionCast.cast(CommonEnum.DELETE_FLAG.getCodeInt().equals(status), ContentErrorCode.E_120022);

        //课程审核状态 不能是已提交与审核通过  才能提交进行审核
        String auditStatus = courseBase.getAuditStatus();
        if (CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode().equals(auditStatus) ||
                CourseAuditEnum.AUDIT_PASTED_STATUS.getCode().equals(auditStatus)
        ) {
            ExceptionCast.cast(ContentErrorCode.E_120024);
        }

        //修改数据
        //audtiStatus 审核状态--已提交
        String code = CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode();

        LambdaUpdateWrapper<CourseBase> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(CourseBase::getAuditStatus, code);
        updateWrapper.eq(CourseBase::getId, courseBaseId);
        queryWrapper.eq(CourseBase::getCompanyId, companyId);
        boolean update = this.update(updateWrapper);
        //判断修改是否成功
        if (!update) {
            ExceptionCast.cast(ContentErrorCode.E_120010);
        }
    }

    /* 业务分析
       关键数据 courseBaseId  auditMind  auditStatus 不为空
        业务数据
              课程基本信息 不为空
              课程是否删除
              课程审核状态 只能是已提交 才能提交进行审核
        修改数据
               auditStatus 审核状态--审核通过或不通过
               auditMind  审核意见
               auditNums 审核次数+1
               auditDate 审核时间
               auditPeople 审核人 暂时没有(前端未传)

        判断修改是否成功

     */
    @Transactional
    public void modifyMCourseBaseById(Long courseBaseId, String auditMind, String auditStatus) {
        //关键数据 courseBaseId  auditMind  auditStatus 不为空

        if (ObjectUtils.isEmpty(courseBaseId) ||
                StringUtil.isBlank(auditMind) ||
                StringUtil.isBlank(auditStatus)
        ) {
            ExceptionCast.cast(ContentErrorCode.E_120023);
        }

        //判断关键数据
        //课程基本信息 不为空
        CourseBase courseBase = this.getById(courseBaseId);
        ExceptionCast.cast(ObjectUtils.isEmpty(courseBase), ContentErrorCode.E_120013);

        //课程是否删除
        Integer status = courseBase.getStatus();
        ExceptionCast.cast(CommonEnum.DELETE_FLAG.getCodeInt().equals(status), ContentErrorCode.E_120022);


        //课程审核状态 只能是已提交 才能提交进行审核
        ExceptionCast.cast(!CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode().equals(courseBase.getAuditStatus()), ContentErrorCode.E_120015);


        //修改数据
        LambdaUpdateWrapper<CourseBase> updateWrapper = new LambdaUpdateWrapper<>();

        //auditStatus 审核状态--审核通过或不通过
        updateWrapper.set(CourseBase::getAuditStatus, auditStatus);

        //auditMind  审核意见
        updateWrapper.set(CourseBase::getAuditMind, auditMind);

        //auditNums 审核次数+1
        Integer auditNums = courseBase.getAuditNums();
        //不存在就是第一次修改
        if (ObjectUtils.isEmpty(auditNums)) {
            courseBase.setAuditNums(1);
        } else {
            //存在 次数+1
            courseBase.setAuditNums(auditNums + 1);
        }
        updateWrapper.set(CourseBase::getAuditNums, auditNums);

        //auditDate 审核时间
        updateWrapper.set(CourseBase::getAuditDate, LocalDateTime.now());
        //根据课程ID修改
        updateWrapper.eq(CourseBase::getId, courseBaseId);

        boolean update = this.update(updateWrapper);
        //判断修改是否成功
        if (!update) {
            ExceptionCast.cast(ContentErrorCode.E_120010);
        }

    }

    /* 根据课程ID查询教师信息
     关键数据 courseBaseId   companyId 不为空
     业务数据
        查询课程信息 -- 同一家机构 --未删除
        调用courseTeacherService层 方法 查询教师信息
       将查询到的数据返回
     */
    public List<CourseTeacherDTO> queryCourseTeachers(Long courseBaseId, Long companyId) {
        //courseBaseId   companyId 不为空
        if (ObjectUtils.isEmpty(courseBaseId) ||
                ObjectUtils.isEmpty(companyId)) {
            ExceptionCast.cast(ContentErrorCode.E_120023);
        }
        //查询课程信息 --是否存在 同一家机构 --未删除
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseBase::getId, courseBaseId);
        queryWrapper.eq(CourseBase::getCompanyId, companyId);
        CourseBase course = this.getOne(queryWrapper);
        //是否存在
        ExceptionCast.cast(ObjectUtils.isEmpty(course), ContentErrorCode.E_120013);

        //未删除
        ExceptionCast.cast(CommonEnum.DELETE_FLAG.getCodeInt().equals(course.getStatus()), ContentErrorCode.E_120013);

        //调用courseTeacherService层 方法 查询教师信息
        List<CourseTeacherDTO> courseTeacherDTOS = courseTeacherService.queryCourseTeacher(courseBaseId);


        return courseTeacherDTOS;
    }


    /*
    根据courseId和companyId查询课程基础信息
    判断是否被删除，是否存在，是否同一家机构
    审核状态是否为未提交或审核未通过
     */
    public CourseBase getCourseBase(Long courseBaseId, Long companyId) {

        //查询课程信息 --是否存在 同一家机构 --未删除
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseBase::getId, courseBaseId);
        queryWrapper.eq(CourseBase::getCompanyId, companyId);
        CourseBase course = this.getOne(queryWrapper);
        //是否存在
        ExceptionCast.cast(ObjectUtils.isEmpty(course), ContentErrorCode.E_120013);
        //审核状态是否为未提交或审核未通过或未审核 或未审核
        if (AuditEnum.AUDIT_UNPAST_STATUS.getCode().equals(course.getAuditStatus()) ||
                AuditEnum.AUDIT_DISPAST_STATUS.getCode().equals(course.getAuditStatus()) ||
                CourseAuditEnum.AUDIT_UNPAST_STATUS.getCode().equals(course.getAuditStatus())
        ) {  }else{
            //不是这三种审核状态 抛异常
            ExceptionCast.cast(ContentErrorCode.E_120011);
        }

        return course;

    }

    /*
    关键数据 courseBaseId companyId 不为空
    课程计划绑定媒资信息 查询课程基本信息
     是否存在 是否删除审核状态：未提交、审核未通过 同一家机构
     否是录播课程（只有录播课程才可以绑定资源）
     */
    public CourseBaseDTO queryCourseByID(Long courseBaseId, Long companyId) {
        //关键数据 courseBaseId   companyId 不为空
        if ( ObjectUtils.isEmpty(companyId)||
                ObjectUtils.isEmpty(courseBaseId) ) {
            ExceptionCast.cast(ContentErrorCode.E_120023);
        }

        //查询课程基本信息 课程ID 机构ID
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseBase::getId, courseBaseId);
        queryWrapper.eq(CourseBase::getCompanyId, companyId);
        CourseBase course = this.getOne(queryWrapper);
        //是否存在 是否删除 同一家机构    审核状态：是否为未提交、审核未通过
        //     否是录播课程（只有录播课程才可以绑定资源）

        // 是否存在 是否删除 否是录播课程
        if (ObjectUtils.isEmpty(course)||
                CommonEnum.DELETE_FLAG.getCodeInt().equals(course.getStatus())||
                !(CourseModeEnum.COURSE_MODE_RECORD_STATUS.equals(course.getTeachmode()))){
            ExceptionCast.cast(ContentErrorCode.E_120025);
        }
        //审核状态：是否为未提交、审核未通过
        String auditStatus = course.getAuditStatus();
        if (CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode().equals(auditStatus)||
        CourseAuditEnum.AUDIT_PASTED_STATUS.getCode().equals(auditStatus)||
        CourseAuditEnum.AUDIT_PUBLISHED_STATUS.getCode().equals(auditStatus)){
            //当为 已提交 审核通过  已发布时 不可修改
            ExceptionCast.cast(ContentErrorCode.E_120024);
        }
        CourseBaseDTO dto = CourseBaseConvert.INSTANCE.entity2dto(course);

        return dto;
    }

}
